home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’96 / DragClick / Sources / LayerMgr.h < prev    next >
Text File  |  1996-06-21  |  4KB  |  120 lines
  1. #ifndef __LAYERMGR__
  2. #define __LAYERMGR__
  3.  
  4. #ifndef __PROCESSES__
  5. #include <Processes.h>
  6. #endif
  7.  
  8.  
  9. /* Part of the undocumented Layer Manager structures and calls
  10.  * Information found with the help of MacsBug under MacOS 7.0.
  11.  * Please note that using this information may make your mac
  12.  * explode (hey, this could be a subject for a QuickTime moovie !);
  13.  * so use at your own risks, this may break in the future,
  14.  * etc.. (usual disclaimeer).
  15.  * I only wish that Apple will document this manager in a very near
  16.  * future (let's dream...).
  17.  *
  18.  * What I found was that a layer is associated with each running
  19.  * applications (if it has a user-interface), which groups all
  20.  * windows of that application. This is how you can hide an application
  21.  * (remember 'applications' menu under system 7) and get the list of
  22.  * other applications windows. Have fun.
  23.  *
  24.  * PS : If you have more information on the Layer Manager, please
  25.  * let me know! You can join me at hugues@isoft.fr
  26.  */
  27.  
  28. #define _LayerDispatch  0xA829
  29.  
  30. typedef WindowPtr LayerPtr;
  31.  
  32. // This records some information on the process which owns
  33. // the layer... Most of it is not clear (there are pointers
  34. // to other LayerRecords, to a heap zone, etc. in the unknown
  35. // parts)
  36.  
  37. typedef struct {
  38.         long                            unknown1;
  39.         OSType                          signature;
  40.         OSType                          creator;
  41.         char                            unknown2[24];
  42.         ProcessSerialNumber               layerPSN;
  43.         char                            unknown3[40];
  44.         Handle                          moreLayerInfo;
  45. } LayerInfo, *LayerInfoPtr;
  46.  
  47. typedef struct {
  48.     GrafPort                    port;                
  49.     short                       windowKind;
  50.     Boolean                     visible;
  51.     Boolean                     hilited;
  52.     Boolean                     metaLayer;
  53.     Boolean                     spareFlag;
  54.     RgnHandle                   strucRgn;
  55.     RgnHandle                   contRgn;
  56.     RgnHandle                   updateRgn;
  57.     Handle                      windowDefProc;
  58.     LayerPtr                    parentLayer;
  59.     AuxWinHandle                auxWinHead;
  60.     short                       titleWidth;
  61.     AuxCtlHandle                auxCtlHead;
  62.     LayerPtr                    nextLayer;
  63.     WindowPtr                   windowList;
  64.     LayerInfoPtr                layerInfo;
  65. } LayerRecord, *LayerPeek;
  66.  
  67.  
  68. typedef short   WindowActionCode;
  69. enum {
  70.         kNextWindow = 0,
  71.         kNextLayer = 700,
  72.         kBreak
  73. };
  74.  
  75. typedef pascal WindowActionCode ( *LayerActionProcPtr )(
  76.         WindowPtr theWindow, LayerPtr theLayer, long refCon );
  77.  
  78. #define kAllLayers ((LayerPtr)-1)
  79.  
  80. // Call the action proc for each window in each layer
  81.  
  82. pascal WindowActionCode ForEachLayerWindowDo(
  83.         LayerPtr layer1, LayerPtr layer2, LayerPtr layer3,
  84.         LayerActionProcPtr layerAction, long refCon ) = { 0x70F8, _LayerDispatch
  85. };
  86.  
  87. // Return the window's layer
  88. pascal LayerPtr WindowLayer( WindowPtr theWindow ) = { 0x70F9,
  89. _LayerDispatch };
  90.  
  91. // Return the frontmost visible window in the given layer
  92. pascal WindowPtr LayerFrontVisibleWindow( LayerPtr theLayer )
  93.         = { 0x70FD, _LayerDispatch };
  94.  
  95. // Return the frontmost visible window on the desktop
  96. pascal WindowPtr DeskFrontVisibleWindow( void ) = { 0x70FE,
  97. _LayerDispatch };
  98.  
  99. // Return the desktop's layer (contains all other layers)
  100. pascal LayerPtr DeskLayer( void ) = { 0x70FF, _LayerDispatch };
  101.  
  102. // Return TRUE if theLayer is really a LayerPtr; return FALSE if it's a WindowPtr
  103. pascal Boolean IsLayer( LayerPtr theLayer ) = { 0x7002, _LayerDispatch };
  104.  
  105. // Return the current process' layer
  106. pascal LayerPtr CurrentLayer( void ) = { 0x7003, _LayerDispatch };
  107.  
  108. // Return the first window of this layer.
  109. pascal WindowPtr LayerFrontWindow( LayerPtr theLayer ) = { 0x7006,
  110. _LayerDispatch };
  111.  
  112. // All-layer version of FindWindow
  113. pascal short FindLayerWindow( Point where, WindowPtr *foundWindow )
  114.         = { 0x7007, _LayerDispatch };
  115.  
  116. #define LayerVisible(aLayer)    (((LayerPeek)aLayer)->visible)
  117.  
  118. #endif
  119.  
  120.